package v1

import (
	"fmt"
	"strconv"
	"wms/internal/model/request"
	"wms/internal/service"
	"wms/pkg/common"
	"wms/pkg/logger"

	"github.com/gin-gonic/gin"
	"go.uber.org/zap"
)

// SupplierController 供应商控制器
type SupplierController struct {
	service *service.SupplierService
}

// NewSupplierController 创建供应商控制器
func NewSupplierController() *SupplierController {
	return &SupplierController{
		service: service.NewSupplierService(),
	}
}

// Create godoc
// @Summary 创建供应商
// @Description 创建新的供应商
// @Tags 供应商管理
// @Accept json
// @Produce json
// @Security Bearer
// @Param request body request.SupplierCreateRequest true "供应商信息"
// @Success 200 {object} common.Response "成功"
// @Failure 400 {object} common.Response "请求错误"
// @Failure 500 {object} common.Response "内部错误"
// @Router /suppliers [post]
func (c *SupplierController) Create(ctx *gin.Context) {
	var req request.SupplierCreateRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		logger.Warn("绑定创建供应商请求参数失败", zap.Error(err))
		common.Error(ctx, fmt.Errorf("无效的请求参数：%s", err.Error()))
		return
	}

	// 获取当前用户ID
	userID := common.GetUserID(ctx)

	if err := c.service.CreateSupplier(&req, userID); err != nil {
		logger.Error("创建供应商失败", zap.Error(err), zap.Any("req", req))
		common.Error(ctx, fmt.Errorf("创建供应商失败：%s", err.Error()))
		return
	}

	logger.Info("创建供应商成功")
	common.Success(ctx, nil)
}

// Update godoc
// @Summary 更新供应商
// @Description 更新供应商信息
// @Tags 供应商管理
// @Accept json
// @Produce json
// @Security Bearer
// @Param id path int true "供应商ID"
// @Param request body request.SupplierUpdateRequest true "供应商信息"
// @Success 200 {object} common.Response "成功"
// @Failure 400 {object} common.Response "请求错误"
// @Failure 500 {object} common.Response "内部错误"
// @Router /suppliers/{id} [put]
func (c *SupplierController) Update(ctx *gin.Context) {
	id, err := strconv.ParseUint(ctx.Param("id"), 10, 32)
	if err != nil {
		logger.Warn("解析供应商ID失败", zap.Error(err))
		common.Error(ctx, fmt.Errorf("无效的供应商ID"))
		return
	}

	var req request.SupplierUpdateRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		logger.Warn("绑定更新供应商请求参数失败", zap.Error(err))
		common.Error(ctx, fmt.Errorf("无效的请求参数：%s", err.Error()))
		return
	}

	// 获取当前用户ID
	userID := common.GetUserID(ctx)

	req.ID = uint(id)
	if err := c.service.UpdateSupplier(&req, userID); err != nil {
		logger.Error("更新供应商失败", zap.Error(err), zap.Any("req", req))
		common.Error(ctx, fmt.Errorf("更新供应商失败：%s", err.Error()))
		return
	}

	logger.Info("更新供应商成功")
	common.Success(ctx, nil)
}

// Delete godoc
// @Summary 删除供应商
// @Description 删除指定供应商
// @Tags 供应商管理
// @Accept json
// @Produce json
// @Security Bearer
// @Param id path int true "供应商ID"
// @Success 200 {object} common.Response "成功"
// @Failure 400 {object} common.Response "请求错误"
// @Failure 500 {object} common.Response "内部错误"
// @Router /suppliers/{id} [delete]
func (c *SupplierController) Delete(ctx *gin.Context) {
	id, err := strconv.ParseUint(ctx.Param("id"), 10, 32)
	if err != nil {
		logger.Warn("解析供应商ID失败", zap.Error(err))
		common.Error(ctx, fmt.Errorf("无效的供应商ID"))
		return
	}

	// 获取当前用户ID
	userID := common.GetUserID(ctx)

	if err := c.service.DeleteSupplier(uint(id), userID); err != nil {
		logger.Error("删除供应商失败", zap.Error(err), zap.Uint("id", uint(id)))
		common.Error(ctx, fmt.Errorf("删除供应商失败：%s", err.Error()))
		return
	}

	logger.Info("删除供应商成功")
	common.Success(ctx, nil)
}

// Get godoc
// @Summary 获取供应商详情
// @Description 获取指定供应商的详细信息
// @Tags 供应商管理
// @Accept json
// @Produce json
// @Security Bearer
// @Param id path int true "供应商ID"
// @Success 200 {object} common.Response{data=model.Supplier} "成功"
// @Failure 400 {object} common.Response "请求错误"
// @Failure 500 {object} common.Response "内部错误"
// @Router /suppliers/{id} [get]
func (c *SupplierController) Get(ctx *gin.Context) {
	id, err := strconv.ParseUint(ctx.Param("id"), 10, 32)
	if err != nil {
		logger.Warn("解析供应商ID失败", zap.Error(err))
		common.Error(ctx, fmt.Errorf("无效的供应商ID"))
		return
	}

	supplier, err := c.service.GetSupplierByID(uint(id))
	if err != nil {
		logger.Error("获取供应商详情失败", zap.Error(err), zap.Uint("id", uint(id)))
		common.Error(ctx, fmt.Errorf("获取供应商详情失败：%s", err.Error()))
		return
	}

	common.Success(ctx, supplier)
}

// List godoc
// @Summary 获取供应商列表
// @Description 获取供应商列表，支持分页和搜索
// @Tags 供应商管理
// @Accept json
// @Produce json
// @Security Bearer
// @Param page query int false "页码" default(1)
// @Param page_size query int false "每页数量" default(10)
// @Param keyword query string false "搜索关键词"
// @Success 200 {object} common.Response{data=[]model.Supplier} "成功"
// @Failure 400 {object} common.Response "请求错误"
// @Failure 500 {object} common.Response "内部错误"
// @Router /suppliers [get]
func (c *SupplierController) List(ctx *gin.Context) {
	var req request.SupplierListRequest
	if err := ctx.ShouldBindQuery(&req); err != nil {
		logger.Warn("绑定供应商列表请求参数失败", zap.Error(err))
		common.Error(ctx, fmt.Errorf("无效的请求参数：%s", err.Error()))
		return
	}

	list, total, err := c.service.ListSuppliers(&req)
	if err != nil {
		logger.Error("获取供应商列表失败", zap.Error(err), zap.Any("req", req))
		common.Error(ctx, fmt.Errorf("获取供应商列表失败：%s", err.Error()))
		return
	}

	common.Success(ctx, gin.H{
		"list":  list,
		"total": total,
		"page":  req.Page,
		"size":  req.PageSize,
	})
}
